Stack (Yığıt)

Bilgisayar biliminde, yığıt (stack), verilerin düzenli bir şekilde saklanmasına ve yönetilmesine izin veren bir veri yapısıdır. Yığıt, son giren ilk çıkar (Last In First Out - LIFO) mantığına dayanarak çalışır. Bu, son eklenen verinin, yığının en üstüne eklenmesi ve son eklenen verinin ilk olarak çıkarılması anlamına gelir.

Yığıt, bir bellek bölgesi içinde oluşturulur ve burada veriler yalnızca belirli yöntemlerle eklenir ve çıkarılır. Bu yöntemler, yığının işlevselliğini ve güvenliğini sağlamak için önceden tanımlanır.

Yığıt veri yapısı, özellikle derleyiciler, yığın tabanlı bellek yönetimi, programlama dilleri ve işletim sistemleri gibi birçok alanda yaygın olarak kullanılır.

Stack Kullanım Alanları

Yığıtlar (stacks), bilgisayar biliminde birçok alanda kullanılır. İşte bazı örnekler:

1. Bellek yönetimi: Yığıt, programlar tarafından kullanılan bellek yönetiminde önemli bir rol oynar. Programlar, değişkenleri ve fonksiyon çağrıları için yığıt belleğinde yer ayırabilirler.
2. Derleyiciler: Derleyiciler, yığıtı kullanarak programların çalışma zamanında bellek kullanımını optimize edebilirler.
3. İşletim sistemleri: İşletim sistemleri, yığın kullanarak süreçlerin çağrı ve dönüş işlemlerini yönetebilirler.
4. Otomatik hafıza yönetimi: Yığıt, otomatik hafıza yönetiminde kullanılabilir. Bu yöntem, programlama dillerinin hafıza kullanımını otomatik olarak yönetmesine izin verir.
5. Sembolik hesaplama: Yığıt, sembolik hesaplama ve tersine mühendislik gibi matematiksel işlemlerde kullanılabilir.
6. Yığın tabanlı algoritmalar: Yığın tabanlı algoritmalar, yığını kullanarak arama, sıralama ve gezinme gibi işlemleri gerçekleştirebilirler.

Bu, yığıtların kullanılabileceği bazı alanlardır, ancak bu liste tam değildir. Yığıtların esnekliği ve kullanım kolaylığı nedeniyle, birçok farklı alanda kullanılabilirler.

Diziler ile Stack işlemleri (Push Pop Peek)

Diziler (arrays) ile stack işlemleri yapmak için, bir dizi içinde yığıtın elemanlarını depolayabilirsiniz. Böylece, yığıtın elemanlarını dizinin belirli bir bölgesinde saklayabilir ve yığıt işlemlerini gerçekleştirebilirsiniz.

Push, pop ve peek, yığıt işlemlerinin temel kavramlarıdır:

• Push: Yığıtın üstüne bir eleman eklemek için kullanılır. Yani, yeni bir eleman yığıtın en üstüne eklenir.
• Pop: Yığıtın en üstündeki elemanı çıkarmak için kullanılır. Bu, yığıtın en üstündeki elemanın çıkarılması ve yığının boyutunun azaltılması anlamına gelir.
• Peek: Yığıtın en üstündeki elemana bakmak için kullanılır. Bu işlem, yığıtın en üstündeki elemanı çıkarmadan sadece ona bakmanızı sağlar.

Örneğin, bir dizi kullanarak bir yığıt oluşturmak için aşağıdaki gibi bir kod yazabilirsiniz:

int stack[100]; // 100 elemanlı bir dizi kullanarak bir yığın oluşturulur.
int top = -1; // yığının başlangıçta boş olacağını varsayarak, yığının üstünü gösteren bir indeks değeri -1 olarak tanımlanır.

void push(int element) {
    top++; // yığının üstüne yeni bir eleman eklemek için top değeri artırılır.
    stack[top] = element; // yığının üstüne yeni eleman eklenir.
}

int pop() {
    int element = stack[top]; // yığının en üstündeki elemanı almak için top değerini kullanarak bir indeks hesaplanır.
    top--; // yığının en üstündeki elemanı çıkarmak için top değeri azaltılır.
    return element; // yığının en üstündeki eleman geri döndürülür.
}

int peek() {
    return stack[top]; // yığının en üstündeki eleman döndürülür.
}

Bu örnek kod, bir diziyi kullanarak bir yığıt oluşturur ve push, pop ve peek işlemlerini gerçekleştirir. Bu işlemler, yığının elemanlarını ekleme, çıkarma ve görüntüleme için kullanılır.

Bağlı Listeler ile Yığıt işlemleri (Push Pop Peek)

Bağlı listeler (linked lists) yığın, düğümler (nodes) olarak adlandırılan bir veri yapısında depolanır. Her düğüm, yığının bir elemanını ve yığının bir sonraki elemanının konumunu tutar. Bu nedenle, bağlı listeler yığınlar için ideal bir veri yapısıdır çünkü eleman ekleme veya çıkarma işlemleri için herhangi bir bellek kopyalama gerektirmezler.

İşte bağlı listeler yığın için Push, Pop ve Peek fonksiyonlarını içeren bir örnek C kodu:

#include <stdio.h>
#include <stdlib.h>

// Düğüm yapısı
struct Node {
    int data;
    struct Node* next;
};

// Yığın yapısı
struct Stack {
    struct Node* top;
};

// Yeni bir düğüm oluşturma fonksiyonu
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Yığının en üstüne eleman ekleme işlemi
void push(struct Stack* stack, int data) {
    struct Node* newNode = createNode(data);
    newNode->next = stack->top;
    stack->top = newNode;
}

// Yığının en üstünden eleman çıkarma işlemi
int pop(struct Stack* stack) {
    if (stack->top == NULL) {
        printf("Stack is empty.");
        return -1;
    }
    int poppedValue = stack->top->data;
    struct Node* temp = stack->top;
    stack->top = stack->top->next;
    free(temp);
    return poppedValue;
}

// Yığının en üstündeki elemana bakma işlemi
int peek(struct Stack* stack) {
    if (stack->top == NULL) {
        printf("Stack is empty.");
        return -1;
    }
    return stack->top->data;
}

// Test kodu
int main() {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->top = NULL;

    push(stack, 1);
    push(stack, 2);
    push(stack, 3);
    push(stack, 4);

    printf("Top element: %d\n", peek(stack));

    printf("Popped element: %d\n", pop(stack));
    printf("Popped element: %d\n", pop(stack));
    printf("Popped element: %d\n", pop(stack));
    printf("Popped element: %d\n", pop(stack));
    printf("Popped element: %d\n", pop(stack));

    return 0;
}

Bu kodda, yığın yapısı struct Stack ve düğüm yapısı struct Node olarak tanımlanmıştır. createNode fonksiyonu, verilen değeri ve boş bir sonraki düğüm işaretçisini kullanarak yeni bir düğüm oluşturur.

push fonksiyonu, yeni bir düğüm oluşturur ve yığıtın en üstüne ekler. pop fonksiyonu, yığıtın en üstündeki elemanı çıkarır ve geri döndürür. peek fonksiyonu, yığıtın en üstündeki elemana bakar ve bu elemanın değerini geri döndürür. Yani, yığıtın üstündeki elemanın değerini öğrenmek için kullanılır. Ancak, peek fonksiyonu yığıt elemanlarını değiştirmez, yalnızca yığıtın en üstündeki elemanın değerine erişim sağlar.

Stack ile Kelimeyi Tersten Yazdırma

İşte Stack kullanarak WebDernegi kelimesini tersten yazdıran bir C kodu örneği:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 50

// Yığıt yapısı
struct Stack {
    int top;
    char arr[MAX_SIZE];
};

// Yeni bir yığıt oluşturma fonksiyonu
struct Stack* createStack() {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->top = -1;
    return stack;
}

// Yığıta eleman ekleme işlemi
void push(struct Stack* stack, char value) {
    if (stack->top == MAX_SIZE - 1) {
        printf("Stack is full.");
        return;
    }
    stack->arr[++stack->top] = value;
}

// Yığıttan eleman çıkarma işlemi
char pop(struct Stack* stack) {
    if (stack->top == -1) {
        printf("Stack is empty.");
        return -1;
    }
    return stack->arr[stack->top--];
}

// Yığıtın en üstündeki elemana bakma işlemi
char peek(struct Stack* stack) {
    if (stack->top == -1) {
        printf("Stack is empty.");
        return -1;
    }
    return stack->arr[stack->top];
}

// Ana fonksiyon
int main() {
    struct Stack* stack = createStack();
    char str[] = "WebDernegi";
    int i;

    // Kelimeyi yığıta ekleyin
    for (i = 0; i < strlen(str); i++) {
        push(stack, str[i]);
    }

    // Kelimeyi tersten yazdırın
    printf("Kelimenin ters hali: ");
    for (i = 0; i < strlen(str); i++) {
        printf("%c", pop(stack));
    }

    return 0;
}